Este método consiste en repetir el experimento varia veces partiendo los datos y luego calcular la media obtenidas de las medias de evaluación . Con esto se busca estimar la precisión del modelo y optimizar los parámetros de este.


Partición simple

Este método consiste en partir de forma aleatoria del conjunto de datos en dos nuevos conjuntos, de los cuales uno de esos sirve para construir los modelos y el otro para validar su efectividad.



library(caret)
library(devtools)


set.seed(2018) # semilla aleatoria para que al correr siempre de mismo resultado

index <- createDataPartition(data$y, p=0.8, list = F)
train <- data[index, ] # conjunto de entrenamiento
test <- data[-index, ] # Conjunto de prueba
  • p : Permite definir el total de unidades usadas en el conjunto de entrenamiento.
  • data$y : Variabe dependiente de la base de datos.
  • list = F : Que no me imprima los resultados como una lista.

Nota: Este método puede ser muy ágil para procesar los datos aunque puede no ofrecer una validación confiable ya que en ocasiones el resultado de la validación depende de como partamos los datos.

Validación cruzada de K iteraciones

Los datos son divididos en k subconjuntos, de los cuales k-1 subconjuntos son tomados como conjunto de entrenamiento y el subconjunto restante como conjunto de prueba. Este proceso es repetido k iteraciones.

El error total es calculado de la siguiente manera :

\[E = \frac{1}{K}\sum_{i=1}^k E_i\]



library(caret)
## Warning: package 'caret' was built under R version 3.5.2
## Warning: package 'ggplot2' was built under R version 3.5.2
data <- sample(1:20, size = 80, replace = TRUE)
(folds <- groupKFold(data, k = 10))
## $Fold01
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 16 17 18 19 20 21 22 23 24
## [24] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
## [47] 48 49 50 51 52 53 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
## [70] 72 73 74 75 76 77 78 79 80
## 
## $Fold02
##  [1]  1  2  4  6  7  8  9 10 11 12 13 14 15 18 19 20 21 23 24 25 26 27 28
## [24] 29 30 31 33 34 35 36 37 38 39 41 42 43 44 46 47 48 49 50 51 52 53 54
## [47] 56 57 58 59 60 61 63 64 65 66 67 68 69 70 72 73 74 75 76 77 78 79 80
## 
## $Fold03
##  [1]  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 19 20 21 22 23 24 25
## [24] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
## [47] 49 50 52 53 54 55 56 57 58 59 60 62 63 64 65 66 67 68 69 70 71 72 73
## [70] 74 75 76 77 78 79
## 
## $Fold04
##  [1]  1  2  3  4  5  6  7  8  9 11 12 13 14 15 16 17 18 19 21 22 23 24 25
## [24] 27 28 29 31 32 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
## [47] 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 69 70 71 72 73 74 76
## [70] 77 79 80
## 
## $Fold05
##  [1]  1  2  3  4  5  6  7  8  9 10 12 13 15 16 17 18 19 20 21 22 23 24 26
## [24] 27 28 29 30 31 32 33 34 38 39 40 41 42 43 45 46 47 48 49 50 51 52 53
## [47] 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
## [70] 78 79 80
## 
## $Fold06
##  [1]  1  3  4  5  6  9 10 11 12 13 14 15 16 17 18 20 21 22 23 24 25 26 27
## [24] 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 48 49 50 51
## [47] 52 53 54 55 56 57 58 59 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
## [70] 76 77 78 79 80
## 
## $Fold07
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 22 23 25
## [24] 26 27 28 29 30 31 32 33 34 35 36 37 38 40 41 42 44 45 46 47 48 49 50
## [47] 51 52 53 54 55 56 57 59 60 61 62 64 65 67 68 69 70 71 72 74 75 77 78
## [70] 80
## 
## $Fold08
##  [1]  1  2  3  5  6  7  8  9 10 11 13 14 15 16 17 18 19 20 21 22 23 24 25
## [24] 26 28 29 30 31 32 33 34 35 36 37 39 40 42 43 44 45 46 47 48 49 50 51
## [47] 53 54 55 56 57 58 59 60 61 62 63 65 66 67 68 69 70 71 73 74 75 76 77
## [70] 78 79 80
## 
## $Fold09
##  [1]  1  2  3  4  5  6  7  8 10 11 12 14 15 16 17 18 19 20 21 22 24 25 26
## [24] 27 29 30 32 33 34 35 36 37 38 39 40 41 43 44 45 47 51 52 54 55 56 58
## [47] 60 61 62 63 64 65 66 67 68 69 71 72 73 74 75 76 77 78 79 80
## 
## $Fold10
##  [1]  1  2  3  4  5  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
## [24] 25 26 27 28 30 31 32 33 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
## [47] 50 51 52 53 54 55 57 58 59 60 61 62 63 64 66 68 70 71 72 73 75 76 77
## [70] 78 79 80

Nota: Aunque este método es bastante bueno para la validación su desventaja es su costo y lentitud computacional. En la práctica el número de k es elegido dependiendo del tamaño del conjunto de datos pero lo más común es elegir k = 10.

Validación cruzada aleatoria

Este método consiste de tomar de forma aleatoria cierta cantidad de los individuos de la bases de datos para forma el conjunto de entrenamiento. Este proceso se repite k iteraciones.

El error total es calculado de la siguiente manera :

\[E = \frac{1}{K}\sum_{i=1}^k E_i\]



(flds <- createFolds(data, k = 10,list = TRUE, returnTrain = T))
## $Fold01
##  [1]  1  2  3  4  5  6  8  9 11 12 13 14 15 17 18 19 20 21 22 23 27 28 29
## [24] 30 31 32 33 34 35 36 37 38 39 40 41 42 44 45 46 47 48 49 50 51 52 53
## [47] 54 55 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 73 74 75 76 77 78
## [70] 79 80
## 
## $Fold02
##  [1]  3  4  6  7  8  9 10 11 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
## [24] 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 47 48 49 50 51
## [47] 52 53 54 55 56 57 59 60 61 63 64 65 66 67 68 69 70 71 72 73 74 75 76
## [70] 77 78 79
## 
## $Fold03
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 14 15 16 17 18 19 20 21 22 23 24
## [24] 25 26 27 28 29 30 31 32 33 34 35 37 38 39 40 41 43 44 45 46 47 48 49
## [47] 50 52 53 55 56 57 58 59 60 61 62 63 64 66 68 69 70 71 72 73 74 75 76
## [70] 77 79 80
## 
## $Fold04
##  [1]  1  2  3  5  6  7  8  9 10 11 12 13 15 16 17 18 20 21 22 23 24 25 26
## [24] 27 28 29 30 31 32 33 34 35 36 38 39 41 42 43 44 45 46 47 48 49 50 51
## [47] 52 53 54 56 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 74 75 76 77
## [70] 78 79 80
## 
## $Fold05
##  [1]  1  2  3  4  5  6  7  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
## [24] 25 26 27 28 29 30 31 32 33 35 36 37 39 40 41 42 43 44 45 46 48 49 50
## [47] 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 67 68 69 70 71 72 73 74
## [70] 76 77 78 79 80
## 
## $Fold06
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 21 22 23 24
## [24] 25 26 27 28 29 30 33 34 35 36 37 38 40 42 43 44 45 46 47 49 50 51 52
## [47] 53 54 55 56 57 58 59 60 62 63 64 65 66 67 68 70 71 72 73 74 75 76 78
## [70] 79 80
## 
## $Fold07
##  [1]  1  2  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
## [24] 25 26 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
## [47] 50 51 52 53 54 55 56 57 58 59 61 62 63 65 66 67 68 69 70 71 72 73 75
## [70] 77 78 80
## 
## $Fold08
##  [1]  1  2  3  4  5  7  8  9 10 12 13 14 16 17 18 19 20 21 22 24 25 26 27
## [24] 28 29 31 32 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
## [47] 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 71 72 73 74 75 76
## [70] 77 78 79 80
## 
## $Fold09
##  [1]  1  2  3  4  5  6  7  8 10 11 12 13 14 15 16 17 19 20 22 23 24 25 26
## [24] 27 30 31 32 33 34 35 36 37 38 39 40 41 42 43 46 47 48 49 50 51 53 54
## [47] 55 56 57 58 59 60 61 62 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78
## [70] 79 80
## 
## $Fold10
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 18 19 20 21 23 24 25
## [24] 26 27 28 29 30 31 32 33 34 36 37 38 39 40 41 42 43 44 45 46 47 48 49
## [47] 51 52 54 55 56 57 58 60 61 62 63 64 65 66 67 69 70 72 73 74 75 76 77
## [70] 78 79 80
  • returnTrain = T : Retornar el conjunto de entrenamiento, si se pone en falta retorna el conjunto de prueba.

Nota: La complicación de este método se puede dar cuando en la selección aleatoria en las k iteraciones puede ocurrir que queden unidades sin probar.

Validación cruzada dejando uno fuera

Este método consiste en realizar N iteraciones donde en cada iteración se deja un solo dato en el conjunto de prueba.

El error total es calculado de la siguiente manera :

\[E = \frac{1}{N}\sum_{i=1}^N E_i\]



library(DMwR)
## Warning: package 'DMwR' was built under R version 3.5.2
data(swiss)

## First the user defined function (note: can have any name)
user.rpart <- function(form, train, test) {
    require(rpart)
    model <- rpart(formula = form,data =  train)
    preds <- predict(model, test)
  
}

## Now the evaluation
eval.res <- loocv(learner('user.rpart'),
                  dataset(Infant.Mortality ~ ., swiss),
                  loocvSettings(1234))
## 
##  LOOCV experiment with verbose =  FALSE  and seed = 1234
## Check a summary of the results
summary(eval.res)
## 
## == Summary of a Leave One Out Cross Validation  Experiment ==
## 
##  LOOCV experiment with verbose =  FALSE  and seed = 1234 
## 
## * Data set ::  swiss
## * Learner  ::  user.rpart  with parameters:
## 
## * Summary of Experiment Results:
##         Rive Gauche
## avg       20.047569
## std        1.976254
## min       17.000000
## max       23.066667
## invalid    0.000000
  • loocvSettings(1234) : Semilla aleatoria.
  • learner('user.rpart') : modelo a usar.
  • dataset(Infant.Mortality ~ ., swiss) : Formula del modelo a usar y base de datos.

Nota: Este método ofrece un errore muy bajo aunque presenta un costo computacional muy grande.